home *** CD-ROM | disk | FTP | other *** search
/ .net 2002 March / DotNetMagazine-Issue107-Coverdisc-NET107-02-03-PCMac.bin / pc / PC Software / picks / HTTrack / httrack-3.22-3.exe / {app} / src / htsbauth.c < prev    next >
Encoding:
C/C++ Source or Header  |  2002-09-21  |  11.8 KB  |  402 lines
  1. /* ------------------------------------------------------------ */
  2. /*
  3. HTTrack Website Copier, Offline Browser for Windows and Unix
  4. Copyright (C) Xavier Roche and other contributors
  5.  
  6. This program is free software; you can redistribute it and/or
  7. modify it under the terms of the GNU General Public License
  8. as published by the Free Software Foundation; either version 2
  9. of the License, or any later version.
  10.  
  11. This program is distributed in the hope that it will be useful,
  12. but WITHOUT ANY WARRANTY; without even the implied warranty of
  13. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14. GNU General Public License for more details.
  15.  
  16. You should have received a copy of the GNU General Public License
  17. along with this program; if not, write to the Free Software
  18. Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  19.  
  20.  
  21. Important notes:
  22.  
  23. - We hereby ask people using this source NOT to use it in purpose of grabbing
  24. emails addresses, or collecting any other private information on persons.
  25. This would disgrace our work, and spoil the many hours we spent on it.
  26.  
  27.  
  28. Please visit our Website: http://www.httrack.com
  29. */
  30.  
  31.  
  32. /* ------------------------------------------------------------ */
  33. /* File: httrack.c subroutines:                                 */
  34. /*       basic authentication: password storage                 */
  35. /* Author: Xavier Roche                                         */
  36. /* ------------------------------------------------------------ */
  37.  
  38.  
  39. #include "htsbauth.h"
  40.  
  41. /* specific definitions */
  42. #include "htsglobal.h"
  43. #include "htslib.h"
  44. #include <stdio.h>
  45. #include <stdlib.h>
  46. #include <string.h>
  47.  
  48. #include "htsnostatic.h"
  49.  
  50. /* END specific definitions */
  51.  
  52. // gestion des cookie
  53. // ajoute, dans l'ordre
  54. // !=0 : erreur
  55. int cookie_add(t_cookie* cookie,char* cook_name,char* cook_value,char* domain,char* path) {
  56.   char* a=cookie->data;
  57.   char* insert;
  58.   char cook[16384];
  59.   // effacer Èventuel cookie en double
  60.   cookie_del(cookie,cook_name,domain,path);
  61.   if ((int)strlen(cook_value)>1024) return -1;                              // trop long
  62.   if ((int)strlen(cook_name)>256) return -1;                                // trop long
  63.   if ((int)strlen(domain)>256) return -1;                                   // trop long
  64.   if ((int)strlen(path)>256) return -1;                                     // trop long
  65.   if ((int)(
  66.     strlen(cookie->data)
  67.     +strlen(cook_value)
  68.     +strlen(cook_name)
  69.     +strlen(domain)
  70.     +strlen(path)
  71.     +256
  72.     ) > cookie->max_len) return -1;               // impossible d'ajouter
  73.  
  74.   insert=a;          // insÈrer ici
  75.   while (*a) {
  76.     if ( strlen(cookie_get(a,2)) <  strlen(path) )      // long. path (le + long est prioritaire)
  77.       a=cookie->data+strlen(cookie->data);    // fin
  78.     else {
  79.       a=strchr(a,'\n');     // prochain champ
  80.       if (a==NULL)
  81.         a=cookie->data+strlen(cookie->data);    // fin
  82.       else
  83.         a++;
  84.       while(*a=='\n') a++;
  85.       insert=a;          // insÈrer ici
  86.     }
  87.   }
  88.   // construction du cookie
  89.   strcpybuff(cook,domain);
  90.   strcatbuff(cook,"\t");
  91.   strcatbuff(cook,"TRUE");
  92.   strcatbuff(cook,"\t");
  93.   strcatbuff(cook,path);
  94.   strcatbuff(cook,"\t");
  95.   strcatbuff(cook,"FALSE");
  96.   strcatbuff(cook,"\t");
  97.   strcatbuff(cook,"1999999999");
  98.   strcatbuff(cook,"\t");
  99.   strcatbuff(cook,cook_name);
  100.   strcatbuff(cook,"\t");
  101.   strcatbuff(cook,cook_value);
  102.   strcatbuff(cook,"\n");
  103.   if (!( ((int) strlen(cookie->data) + (int) strlen(cook)) < cookie->max_len)) return -1;      // impossible d'ajouter
  104.   cookie_insert(insert,cook);
  105. #if DEBUG_COOK
  106.   printf("add_new cookie: name=\"%s\" value=\"%s\" domain=\"%s\" path=\"%s\"\n",cook_name,cook_value,domain,path);
  107.   //printf(">>>cook: %s<<<\n",cookie->data);
  108. #endif
  109.   return 0;
  110. }
  111.  
  112. // effacer cookie si existe
  113. int cookie_del(t_cookie* cookie,char* cook_name,char* domain,char* path) {
  114.   char *a,*b;
  115.   b=cookie_find(cookie->data,cook_name,domain,path);
  116.   if (b) {
  117.     a=cookie_nextfield(b);
  118.     cookie_delete(b,(int) (a - b));
  119. #if DEBUG_COOK
  120.     printf("deleted old cookie: %s %s %s\n",cook_name,domain,path);
  121. #endif
  122.   }
  123.   return 0;
  124. }
  125.  
  126. // rechercher cookie ‡ partir de la position s (par exemple s=cookie.data)
  127. // renvoie pointeur sur ligne, ou NULL si introuvable
  128. // path est alignÈ ‡ droite et cook_name peut Ítre vide (chercher alors tout cookie)
  129. // .doubleclick.net    TRUE    /    FALSE    1999999999    id    A
  130. char* cookie_find(char* s,char* cook_name,char* domain,char* path) {
  131.   char* a=s;
  132.   while (*a) {
  133.     int t;
  134.     if (strnotempty(cook_name)==0)
  135.       t=1;                      // accepter par dÈfaut
  136.     else
  137.       t=( strcmp(cookie_get(a,5),cook_name)==0 );     // tester si mÍme nom
  138.     if (t) {  // mÍme nom ou nom qualconque
  139.       //
  140.       char* chk_dom=cookie_get(a,0);       // domaine concernÈ par le cookie
  141.       if ((int) strlen(chk_dom) <= (int) strlen(domain)) {
  142.         if ( strcmp(chk_dom,domain+strlen(domain)-strlen(chk_dom))==0 ) {  // mÍme domaine
  143.           //
  144.           char* chk_path=cookie_get(a,2);       // chemin concernÈ par le cookie
  145.           if ((int) strlen(chk_path) <= (int) strlen(path)) {
  146.             if (strncmp(path,chk_path,strlen(chk_path))==0 ) { // mÍme chemin
  147.               return a;
  148.             }
  149.           }
  150.         }
  151.       }
  152.     }
  153.     a=cookie_nextfield(a);
  154.   }
  155.   return NULL;
  156. }
  157.  
  158. // renvoie prochain champ
  159. char* cookie_nextfield(char* a) {
  160.   char* b=a;
  161.   a=strchr(a,'\n');     // prochain champ
  162.   if (a==NULL)
  163.     a=b+strlen(b);    // fin
  164.   else
  165.     a++;
  166.   while(*a=='\n') a++;
  167.   return a;
  168. }
  169.  
  170. // lire cookies.txt
  171. // lire Ègalement (Windows seulement) les *@*.txt (cookies IE copiÈs)
  172. // !=0 : erreur
  173. int cookie_load(t_cookie* cookie,char* fpath,char* name) {
  174.   cookie->data[0]='\0';
  175.  
  176.   // Fusionner d'abord les Èventuels cookies IE
  177. #if HTS_WIN
  178.   {
  179.     WIN32_FIND_DATA find;
  180.     HANDLE h;
  181.     char  pth[MAX_PATH + 32];
  182.     strcpybuff(pth,fpath);
  183.     strcatbuff(pth,"*@*.txt");
  184.     h = FindFirstFile(pth,&find);
  185.     if (h != INVALID_HANDLE_VALUE) {
  186.       do {
  187.         if (!(find.dwFileAttributes  & FILE_ATTRIBUTE_DIRECTORY ))
  188.           if (!(find.dwFileAttributes  & FILE_ATTRIBUTE_SYSTEM )) {
  189.             FILE* fp=fopen(fconcat(fpath,find.cFileName),"rb");
  190.             if (fp) {
  191.               char cook_name[256];
  192.               char cook_value[1000];
  193.               char domainpathpath[512];
  194.               //
  195.               char domain[256];           // domaine cookie (.netscape.com)
  196.               char path[256];             // chemin (/)
  197.               int cookie_merged=0;
  198.               linput(fp,cook_name,250);
  199.               if (!feof(fp)) {
  200.                 linput(fp,cook_value,250);
  201.                 if ( (!feof(fp)) && (strnotempty(cook_value)) )  {
  202.                   linput(fp,domainpathpath,500);
  203.                   if (strnotempty(domainpathpath)) {
  204.                     if (ident_url_absolute(domainpathpath,domain,path)>=0) {
  205.                       cookie_add(cookie,cook_name,cook_value,domain,path);
  206.                       cookie_merged=1;
  207.                     }
  208.                   }
  209.                 }
  210.               }
  211.               fclose(fp);
  212.               if (cookie_merged)
  213.                 remove(fconcat(fpath,find.cFileName));
  214.             }  // if fp
  215.           }
  216.       } while(FindNextFile(h,&find));
  217.       FindClose(h);
  218.     }
  219.   }
  220. #endif
  221.   
  222.   // Ensuite, cookies.txt
  223.   {
  224.     FILE* fp = fopen(fconcat(fpath,name),"rb");
  225.     if (fp) {
  226.       char line[8192];
  227.       while( (!feof(fp)) && (((int) strlen(cookie->data)) < cookie->max_len)) {
  228.         rawlinput(fp,line,8100);
  229.         if (strnotempty(line)) {
  230.           if (strlen(line)<8000) {
  231.             if (line[0]!='#') {
  232.               char domain[256];           // domaine cookie (.netscape.com)
  233.               char path[256];             // chemin (/)
  234.               char cook_name[256];        // nom cookie (MYCOOK)
  235.               char cook_value[8192];      // valeur (ID=toto,S=1234)
  236.               strcpybuff(domain,cookie_get(line,0));       // host
  237.               strcpybuff(path,cookie_get(line,2));         // path
  238.               strcpybuff(cook_name,cookie_get(line,5));    // name
  239.               strcpybuff(cook_value,cookie_get(line,6));   // value
  240. #if DEBUG_COOK
  241.               printf("%s\n",line);
  242. #endif
  243.               cookie_add(cookie,cook_name,cook_value,domain,path);
  244.             }
  245.           }
  246.         }
  247.       }
  248.       fclose(fp);
  249.       return 0;
  250.     }
  251.   }
  252.   return -1;
  253. }
  254.  
  255. // Ècrire cookies.txt
  256. // !=0 : erreur
  257. int cookie_save(t_cookie* cookie,char* name) {
  258.   if (strnotempty(cookie->data)) {
  259.     char line[8192];
  260.     FILE* fp = fopen(fconv(name),"wb");
  261.     if (fp) {
  262.       char* a=cookie->data;
  263.       fprintf(fp,"# HTTrack Website Copier Cookie File"LF"# This file format is compatible with Netscape cookies"LF);
  264.       do {
  265.         a+=binput(a,line,8000);
  266.         fprintf(fp,"%s"LF,line);
  267.       } while(strnotempty(line));
  268.       fclose(fp);
  269.       return 0;
  270.     }
  271.   } else
  272.     return 0;
  273.   return -1;
  274. }
  275.  
  276. // insertion chaine ins avant s
  277. void cookie_insert(char* s,char* ins) {
  278.   char* buff;
  279.   if (strnotempty(s)==0) {    // rien ‡ faire, juste concat
  280.     strcatbuff(s,ins);
  281.   } else {
  282.     buff=(char*) malloct(strlen(s)+2);
  283.     if (buff) {
  284.       strcpybuff(buff,s);     // copie temporaire
  285.       strcpybuff(s,ins);      // insÈrer
  286.       strcatbuff(s,buff);     // copier
  287.       freet(buff);
  288.     }
  289.   }
  290. }
  291. // destruction chaine dans s position pos
  292. void cookie_delete(char* s,int pos) {
  293.   char* buff;
  294.   if (strnotempty(s+pos)==0) {    // rien ‡ faire, effacer
  295.     s[0]='\0';
  296.   } else {
  297.     buff=(char*) malloct(strlen(s+pos)+2);
  298.     if (buff) {
  299.       strcpybuff(buff,s+pos);     // copie temporaire
  300.       strcpybuff(s,buff);         // copier
  301.       freet(buff);
  302.     }
  303.   }
  304. }
  305.  
  306. // renvoie champ param de la chaine cookie_base
  307. // ex: cookie_get("ceci est<tab>un<tab>exemple",1) renvoi "un"
  308. char* cookie_get(char* cookie_base,int param) {
  309.   char* buffer;
  310.   //
  311.   char * limit;
  312.   NOSTATIC_RESERVE(buffer, char, 8192);
  313.  
  314.   while(*cookie_base=='\n') cookie_base++;
  315.   limit = strchr(cookie_base,'\n');
  316.   if (!limit) limit=cookie_base+strlen(cookie_base);
  317.   if (limit) {
  318.     if (param) {
  319.       int i;
  320.       for(i=0;i<param;i++) {
  321.         if (cookie_base) {
  322.           cookie_base=strchr(cookie_base,'\t');       // prochain tab
  323.           if (cookie_base) cookie_base++;
  324.         }
  325.       }
  326.     }
  327.     if (cookie_base) {
  328.       if ( cookie_base < limit) {
  329.         char* a = cookie_base;
  330.         while( (*a) && (*a!='\t') && (*a!='\n')) a++;
  331.         buffer[0]='\0';
  332.         strncatbuff(buffer,cookie_base,(int) (a - cookie_base));
  333.         return buffer;
  334.       } else
  335.         return "";
  336.     } else
  337.       return "";
  338.   } else
  339.     return "";
  340. }
  341. // fin cookies
  342.  
  343.  
  344.  
  345. // -- basic auth --
  346.  
  347. /* dÈclarer un rÈpertoire comme possÈdant une authentification propre */
  348. int bauth_add(t_cookie* cookie,char* adr,char* fil,char* auth) {
  349.   if (cookie) {
  350.     if (!bauth_check(cookie,adr,fil)) {       // n'existe pas dÈja
  351.       bauth_chain* chain=&cookie->auth;
  352.       char* prefix=bauth_prefix(adr,fil);
  353.       /* fin de la chaine */
  354.       while(chain->next)
  355.         chain=chain->next;
  356.       chain->next=(bauth_chain*) calloc(sizeof(bauth_chain),1);
  357.       if (chain->next) {
  358.         chain=chain->next;
  359.         chain->next=NULL;
  360.         strcpybuff(chain->auth,auth);
  361.         strcpybuff(chain->prefix,prefix);
  362.         return 1;
  363.       }
  364.     }
  365.   }
  366.   return 0;
  367. }
  368.  
  369. /* tester adr et fil, et retourner authentification si nÈcessaire */
  370. /* sinon, retourne NULL */
  371. char* bauth_check(t_cookie* cookie,char* adr,char* fil) {
  372.   if (cookie) {
  373.     bauth_chain* chain=&cookie->auth;
  374.     char* prefix=bauth_prefix(adr,fil);
  375.     while(chain) {
  376.       if (strnotempty(chain->prefix)) {
  377.         if (strncmp(prefix,chain->prefix,strlen(chain->prefix))==0) {
  378.           return chain->auth;
  379.         }
  380.       }
  381.       chain=chain->next;
  382.     }
  383.   }
  384.   return NULL;
  385. }
  386.  
  387. char* bauth_prefix(char* adr,char* fil) {
  388.   char* prefix;
  389.   char* a;
  390.   NOSTATIC_RESERVE(prefix, char, HTS_URLMAXSIZE*2);
  391.   strcpybuff(prefix,jump_identification(adr));
  392.   strcatbuff(prefix,fil);
  393.   a=strchr(prefix,'?');
  394.   if (a) *a='\0';
  395.   if (strchr(prefix,'/')) {
  396.     a=prefix+strlen(prefix)-1;
  397.     while(*a != '/') a--;
  398.     *(a+1)='\0';
  399.   }
  400.   return prefix;
  401. }
  402.